package com.stefanini.pe.bbva.bp.in.bo.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.pe.bbva.utils.Constantes;
import com.stefanini.pe.bbva.bp.in.bo.datasource.DetallePorContratos;
import com.stefanini.pe.bbva.bp.in.bo.iface.RebalanceoBOIface;
import com.stefanini.pe.bbva.bp.in.dao.iface.RebalanceoDAOIface;
import com.stefanini.pe.bbva.bp.in.to.DetalleRebalanceoTO;
import com.stefanini.pe.bbva.bp.in.to.ListaGenerica;
import com.stefanini.pe.bbva.bp.in.to.PosicionContrato;
import com.stefanini.pe.bbva.bp.in.to.PosicionDetalle;
import com.stefanini.pe.bbva.bp.in.to.Rebalanceo;
import com.stefanini.pe.bbva.bp.in.to.RebalanceoTO;
import com.stefanini.pe.bbva.bp.in.to.TablaGenerica;
import com.stefanini.pe.bbva.bp.in.utils.Util;

@Service("rebalanceoNCBO")
public class RebalanceoNCBOImpl implements RebalanceoBOIface{
	@Autowired  
    @Qualifier("rebalanceoNCDAO")
	private RebalanceoDAOIface rebalanceoDAOIface;
	
	public List<Rebalanceo> listarHistoricosRebalanceo(Rebalanceo oRebalanceo) throws Exception{
		List historicos=new ArrayList();
		for (Iterator iter = rebalanceoDAOIface.listarHistoricosRebalanceo(oRebalanceo).iterator(); iter.hasNext();) {
			Rebalanceo element = (Rebalanceo) iter.next();
			element.setFecharebalanceo(Util.formatDate(element.getFecharebalanceo()));
			element.setSaldoactual(Util.formatDouble(Util.isNumber(element.getSaldoactual())));
			element.setSaldodisponible(Util.formatDouble(Util.isNumber(element.getSaldodisponible())));
			element.setSaldoretenido(Util.formatDouble(Util.isNumber(element.getSaldoretenido())));
			element.setUtilidadperdida(Util.formatDouble(Util.isNumber(element.getUtilidadperdida())));
			historicos.add(element);
		}
		return historicos;
	}

	public List<HashMap> listarArchivosRebalanceo(Rebalanceo oRebalanceo) {
		return rebalanceoDAOIface.listarArchivosRebalanceo(oRebalanceo);
	}
	
	public List<HashMap> listarArchivosRebalanceoNC(Rebalanceo oRebalanceo) {
		return rebalanceoDAOIface.listarArchivosRebalanceoNC(oRebalanceo);
	}

	public void listarPosicionContratoRebalanceado(String codCliente,PosicionContrato objContratoTotal,List listContratoProductos) {
		List lista=rebalanceoDAOIface.listarPosicionContrato(codCliente);
		List subList=new ArrayList();
		ListaGenerica mainList=new ListaGenerica();
		if(lista.size()>0){
		PosicionContrato posicionContrato=(PosicionContrato)lista.get(0);
		String descripcion=Util.isString(posicionContrato.getDescripcioncateporcontrato());
		String codCatContrato=Util.isString(posicionContrato.getCodcategoriaporcontrato());
		Double saldoactualext=new Double(0);
		Double saldoretenidoext=new Double(0);
		Double saldodisponibleext=new Double(0);
		Double utilidadperdida=new Double(0);
		Double peso=new Double(0);
		Double saldoactualext_tt=new Double(0);
		Double saldoretenidoext_tt=new Double(0);
		Double saldodisponibleext_tt=new Double(0);
		Double utilidadperdida_tt=new Double(0);
		Double peso_tt=new Double(0);
		String descripcion_aux="";
		String codCatContrato_aux="";
		PosicionContrato element = null;
		for (Iterator iter = lista.iterator(); iter.hasNext();) {
			element = (PosicionContrato) iter.next();
			if(element.getStrparticiparebalanceo().equals("S")){
			element.setIndparticiparebalanceo(element.getStrparticiparebalanceo().equals("S")?true:false);
			descripcion_aux=descripcion;
			codCatContrato_aux=codCatContrato;
			descripcion=Util.isString(element.getDescripcioncateporcontrato());
			codCatContrato=Util.isString(element.getCodcategoriaporcontrato());
			if(!codCatContrato_aux.equals(codCatContrato)){//CORRECION POR ROGER MATOS
				mainList=new ListaGenerica();
				mainList.setObj(new PosicionContrato());
				mainList.setSubLista(subList);
				llenaTotalesContrato((PosicionContrato)mainList.getObj(),codCatContrato_aux,"Total "+descripcion_aux,saldoactualext,
						saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
				listContratoProductos.add(mainList);
				subList=new ArrayList();
				saldoactualext=new Double(0);
				saldoretenidoext=new Double(0);
				saldodisponibleext=new Double(0);
				utilidadperdida=new Double(0);
				peso=new Double(0);
			}
			saldoactualext+=Util.isNumber(element.getSaldoactualext());
			saldoretenidoext+=Util.isNumber(element.getSaldoretenidoext());
			saldodisponibleext+=Util.isNumber(element.getSaldodisponibleext());
			utilidadperdida+=Util.isNumber(element.getUtilidadperdida());
			peso+=Util.isNumber(element.getPeso());
			saldoactualext_tt+=Util.isNumber(element.getSaldoactualext());
			saldoretenidoext_tt+=Util.isNumber(element.getSaldoretenidoext());
			saldodisponibleext_tt+=Util.isNumber(element.getSaldodisponibleext());
			utilidadperdida_tt+=Util.isNumber(element.getUtilidadperdida());
			peso_tt+=Util.isNumber(element.getPeso());
			subList.add(formateaElementos(element));
			
			}
		}
		mainList=new ListaGenerica();
		
		mainList.setObj(new PosicionContrato());
		llenaTotalesContrato((PosicionContrato)mainList.getObj(),codCatContrato,"Total "+descripcion,saldoactualext,
				saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
		mainList.setSubLista(subList);
		listContratoProductos.add(mainList);
		//Adicinando Totales Finales
		llenaTotalesContrato(objContratoTotal,"","Totales",saldoactualext_tt,
				saldoretenidoext_tt,saldodisponibleext_tt,utilidadperdida_tt,peso_tt);
		}
	}
	
	public void listarPosicionDetalleRebalanceado(String codCliente,PosicionDetalle objContratoTotal,List listContratoProductos) {
		List lista=rebalanceoDAOIface.listarPosicionDetalle(codCliente);
		List subList=new ArrayList();
		ListaGenerica mainList=new ListaGenerica();
		if(lista.size()>0){
		PosicionDetalle posicionDetalle=(PosicionDetalle)lista.get(0);
		String descripcion=Util.isString(posicionDetalle.getDescategoriaporproducto());
		String codCatContrato=Util.isString(posicionDetalle.getIdcategoriaporproducto());
		Double saldoactualext=new Double(0);
		Double saldoretenidoext=new Double(0);
		Double saldodisponibleext=new Double(0);
		Double utilidadperdida=new Double(0);
		Double peso=new Double(0);
		Double saldoactualext_tt=new Double(0);
		Double saldoretenidoext_tt=new Double(0);
		Double saldodisponibleext_tt=new Double(0);
		Double utilidadperdida_tt=new Double(0);
		Double peso_tt=new Double(0);
		String descripcion_aux="";
		String codCatContrato_aux="";
		PosicionDetalle element = null;
		for (Iterator iter = lista.iterator(); iter.hasNext();) {
			element = (PosicionDetalle) iter.next();			
			if(element.getStrparticiparebalanceo().equals("S")){
			descripcion_aux=descripcion;
			codCatContrato_aux=codCatContrato;
			descripcion=Util.isString(element.getDescategoriaporproducto());
			codCatContrato=Util.isString(element.getIdcategoriaporproducto());
			if(!codCatContrato_aux.equals(codCatContrato)){//CORRECCION POR ROGER MATOS
				mainList=new ListaGenerica();
				mainList.setSubLista(subList);
				mainList.setObj(new PosicionDetalle());
				llenaTotalesDetalle((PosicionDetalle)mainList.getObj(),"Total "+descripcion_aux,saldoactualext,
						saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
				listContratoProductos.add(mainList);
				subList=new ArrayList();
				saldoactualext=new Double(0);
				saldoretenidoext=new Double(0);
				saldodisponibleext=new Double(0);
				utilidadperdida=new Double(0);
				peso=new Double(0);
			}
			saldoactualext+=Util.isNumber(element.getSaldoactualext());
			saldoretenidoext+=Util.isNumber(element.getSaldoretenidoext());
			saldodisponibleext+=Util.isNumber(element.getSaldodisponibleext());
			utilidadperdida+=Util.isNumber(element.getUtilidadperdida());
			peso+=Util.isNumber(element.getPeso());
			saldoactualext_tt+=Util.isNumber(element.getSaldoactualext());
			saldoretenidoext_tt+=Util.isNumber(element.getSaldoretenidoext());
			saldodisponibleext_tt+=Util.isNumber(element.getSaldodisponibleext());
			utilidadperdida_tt+=Util.isNumber(element.getUtilidadperdida());
			peso_tt+=Util.isNumber(element.getPeso());
			subList.add(formateaElementosDet(element));
			}
		}
		mainList=new ListaGenerica();
		mainList.setObj(new PosicionDetalle());
		llenaTotalesDetalle((PosicionDetalle)mainList.getObj(),"Total "+descripcion,saldoactualext,
				saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
		mainList.setSubLista(subList);
		listContratoProductos.add(mainList);
		//		Adicinando Totales Finales
		llenaTotalesDetalle(objContratoTotal,"Totales",saldoactualext_tt,
				saldoretenidoext_tt,saldodisponibleext_tt,utilidadperdida_tt,peso_tt);
		}
	}
	
	public void listarPosicionContrato(String codCliente,PosicionContrato objContratoTotal,List listContratoProductos) {
		List lista=rebalanceoDAOIface.listarPosicionContrato(codCliente);
		List subList=new ArrayList();
		ListaGenerica mainList=new ListaGenerica();
		if(lista.size()>0){
			PosicionContrato posicionContrato=(PosicionContrato)lista.get(0);
			String descripcion=Util.isString(posicionContrato.getDescripcioncateporcontrato());
			String descripcionProducto=Util.isString(posicionContrato.getDescripcionproducto());
			String codCatContrato=Util.isString(posicionContrato.getCodcategoriaporcontrato());
			Double saldoactualext=new Double(0);
			Double saldoretenidoext=new Double(0);
			Double saldodisponibleext=new Double(0);
			Double utilidadperdida=new Double(0);
			Double peso=new Double(0);
			Double saldoactualext_tt=new Double(0);
			Double saldoretenidoext_tt=new Double(0);
			Double saldodisponibleext_tt=new Double(0);
			Double utilidadperdida_tt=new Double(0);
			Double peso_tt=new Double(0);
			String descripcion_aux="";
			String codCatContrato_aux="";
			PosicionContrato element = null;
							
			for (Iterator iter = lista.iterator(); iter.hasNext();) {
				element = (PosicionContrato) iter.next();
				element.setIndparticiparebalanceo(element.getStrparticiparebalanceo().equals("S")?true:false);
				descripcion_aux=descripcion;
				codCatContrato_aux=codCatContrato;
				descripcion=Util.isString(element.getDescripcioncateporcontrato());
				codCatContrato=Util.isString(element.getCodcategoriaporcontrato());
				if(!codCatContrato_aux.equals(codCatContrato)){//CORRECCION POR ROGER MATOS
					mainList=new ListaGenerica();
					mainList.setObj(new PosicionContrato());
					mainList.setSubLista(subList);
					llenaTotalesContrato((PosicionContrato)mainList.getObj(),codCatContrato_aux,"Total "+descripcion_aux,saldoactualext,
							saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
					listContratoProductos.add(mainList);
					subList=new ArrayList();
					saldoactualext=new Double(0);
					saldoretenidoext=new Double(0);
					saldodisponibleext=new Double(0);
					utilidadperdida=new Double(0);
					peso=new Double(0);
				}
				saldoactualext+=Util.isNumber(element.getSaldoactualext());
				saldoretenidoext+=Util.isNumber(element.getSaldoretenidoext());
				saldodisponibleext+=Util.isNumber(element.getSaldodisponibleext());
				utilidadperdida+=Util.isNumber(element.getUtilidadperdida());
				peso+=Util.isNumber(element.getPeso());
				saldoactualext_tt+=Util.isNumber(element.getSaldoactualext());
				saldoretenidoext_tt+=Util.isNumber(element.getSaldoretenidoext());
				saldodisponibleext_tt+=Util.isNumber(element.getSaldodisponibleext());
				utilidadperdida_tt+=Util.isNumber(element.getUtilidadperdida());
				peso_tt+=Util.isNumber(element.getPeso());
				subList.add(formateaElementos(element));
			}
			mainList=new ListaGenerica();
			mainList.setObj(new PosicionContrato());
			llenaTotalesContrato((PosicionContrato)mainList.getObj(),codCatContrato,"Total "+descripcion,saldoactualext,
					saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
			mainList.setSubLista(subList);
			listContratoProductos.add(mainList);
			//Adicinando Totales Finales
			llenaTotalesContrato(objContratoTotal,"","Totales",saldoactualext_tt,
					saldoretenidoext_tt,saldodisponibleext_tt,utilidadperdida_tt,peso_tt);
		}
	}
	
	public void listarPosicionDetalle(String codCliente,PosicionDetalle objContratoTotal,List listContratoProductos) {
		List lista=rebalanceoDAOIface.listarPosicionDetalle(codCliente);
		List subList=new ArrayList();
		ListaGenerica mainList=new ListaGenerica();
		if(lista.size()>0){
		PosicionDetalle posicionDetalle=(PosicionDetalle)lista.get(0);
		String descripcion=Util.isString(posicionDetalle.getDescategoriaporproducto());		
		String codCatContrato=Util.isString(posicionDetalle.getIdcategoriaporproducto());
		Double saldoactualext=new Double(0);
		Double saldoretenidoext=new Double(0);
		Double saldodisponibleext=new Double(0);
		Double utilidadperdida=new Double(0);
		Double peso=new Double(0);
		Double saldoactualext_tt=new Double(0);
		Double saldoretenidoext_tt=new Double(0);
		Double saldodisponibleext_tt=new Double(0);
		Double utilidadperdida_tt=new Double(0);
		Double peso_tt=new Double(0);
		String descripcion_aux="";
		String codCatContrato_aux="";
		PosicionDetalle element = null;
		for (Iterator iter = lista.iterator(); iter.hasNext();) {
			element = (PosicionDetalle) iter.next();
			element.setCodcontratoformateado(Util.formatContrato(element.getIdcontratodetalle()));
			descripcion_aux=descripcion;
			codCatContrato_aux=codCatContrato;
			descripcion=Util.isString(element.getDescategoriaporproducto());
			codCatContrato=Util.isString(element.getIdcategoriaporproducto());
			if(!codCatContrato_aux.equals(codCatContrato)){//CORRECCION POR ROGER MATOS
				mainList=new ListaGenerica();
				mainList.setSubLista(subList);
				mainList.setObj(new PosicionDetalle());
				llenaTotalesDetalle((PosicionDetalle)mainList.getObj(),"Total "+descripcion_aux,saldoactualext,
						saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
				listContratoProductos.add(mainList);
				subList=new ArrayList();
				saldoactualext=new Double(0);
				saldoretenidoext=new Double(0);
				saldodisponibleext=new Double(0);
				utilidadperdida=new Double(0);
				peso=new Double(0);
			}
			saldoactualext+=Util.isNumber(element.getSaldoactualext());
			saldoretenidoext+=Util.isNumber(element.getSaldoretenidoext());
			saldodisponibleext+=Util.isNumber(element.getSaldodisponibleext());
			utilidadperdida+=Util.isNumber(element.getUtilidadperdida());
			peso+=Util.isNumber(element.getPeso());
			saldoactualext_tt+=Util.isNumber(element.getSaldoactualext());
			saldoretenidoext_tt+=Util.isNumber(element.getSaldoretenidoext());
			saldodisponibleext_tt+=Util.isNumber(element.getSaldodisponibleext());
			utilidadperdida_tt+=Util.isNumber(element.getUtilidadperdida());
			peso_tt+=Util.isNumber(element.getPeso());
			subList.add(formateaElementosDet(element));
		}
		mainList=new ListaGenerica();
		mainList.setObj(new PosicionDetalle());
		llenaTotalesDetalle((PosicionDetalle)mainList.getObj(),"Total "+descripcion,saldoactualext,
				saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
		mainList.setSubLista(subList);
		listContratoProductos.add(mainList);
		//		Adicinando Totales Finales
		llenaTotalesDetalle(objContratoTotal,"Totales",saldoactualext_tt,
				saldoretenidoext_tt,saldodisponibleext_tt,utilidadperdida_tt,peso_tt);
		}
	}
	
	public void llenaTotalesDetalle(PosicionDetalle posiDetalle,String descripcion, Double saldoactualext,
			Double saldoretenidoext,Double saldodisponibleext,Double utilidadperdida,Double peso){
        posiDetalle.setDescripcionTotal(descripcion);
        posiDetalle.setTotalsaldoactual(Util.formatDouble(saldoactualext));
        posiDetalle.setTotalsaldoretenido(Util.formatDouble(saldoretenidoext));
        posiDetalle.setTotalsaldodisponible(Util.formatDouble(saldodisponibleext));
        posiDetalle.setTotalutilidad(Util.formatDouble(utilidadperdida));
        posiDetalle.setTotalpeso(Util.formatDoublePorcentaje(peso));
	}
	
	public void llenaTotalesContrato(PosicionContrato posiContrato,String codCatContrato,String descripcion, Double saldoactualext,
			Double saldoretenidoext,Double saldodisponibleext,Double utilidadperdida,Double peso){
        posiContrato.setDescripcionTotal(descripcion);
        posiContrato.setTotalsaldoactual(Util.formatDouble(saldoactualext));
        posiContrato.setTotalsaldoretenido(Util.formatDouble(saldoretenidoext));
        posiContrato.setTotalsaldodisponible(Util.formatDouble(saldodisponibleext));
        posiContrato.setTotalutilidad(Util.formatDouble(utilidadperdida));
        posiContrato.setTotalpeso(Util.formatDoublePorcentaje(peso));
		
        posiContrato.setOpcionValores(false);
        posiContrato.setOpcionFondosMutuos(false);
        posiContrato.setOpcionCuentasPersonales(false);
        posiContrato.setOpcionNoDepositos(false);
		
		if(codCatContrato.equals(Constantes.COD_CATXCONTRATO_VAL))
			posiContrato.setOpcionValores(true);
		else if(codCatContrato.equals(Constantes.COD_CATXCONTRATO_FM))
			posiContrato.setOpcionFondosMutuos(true);
		else if(codCatContrato.equals(Constantes.COD_CATXCONTRATO_CAJA))
			posiContrato.setOpcionNoDepositos(true);
		else if(codCatContrato.equals(Constantes.COD_CATXCONTRATO_DEPESTRUC)||codCatContrato.equals(Constantes.COD_CATXCONTRATO_DEPPLAZO))
			posiContrato.setOpcionCuentasPersonales(true);
	}
	
	public PosicionContrato formateaElementos(PosicionContrato element){
        element.setCodcontrato(Util.formatContrato(Util.isString(element.getCodcontrato()).trim()));
        element.setSaldoactualoriginal( Util.formatDouble(Util.isNumber(element.getSaldoactualoriginal())));
		element.setSaldoretenidooriginal( Util.formatDouble(Util.isNumber(element.getSaldoretenidooriginal())));
		element.setSaldodisponibleoriginal( Util.formatDouble(Util.isNumber(element.getSaldodisponibleoriginal())));
		element.setSaldoactualext(Util.formatDouble(Util.isNumber(element.getSaldoactualext())));
		element.setSaldoretenidoext(Util.formatDouble(Util.isNumber(element.getSaldoretenidoext())));
		element.setSaldodisponibleext(Util.formatDouble(Util.isNumber(element.getSaldodisponibleext())));
		element.setUtilidadperdida(Util.formatDouble(Util.isNumber(element.getUtilidadperdida())));
		element.setPeso(Util.formatDoublePorcentaje(Util.isNumber(element.getPeso())));
		return element;
	}
	
	public PosicionDetalle formateaElementosDet(PosicionDetalle element){
        element.setCodcontrato(Util.formatContrato(Util.isString(element.getCodcontrato()).trim()));
        element.setFecvencimiento(Util.formatDate(element.getFecvencimiento()));
		element.setSaldoactualext(Util.formatDouble(Util.isNumber(element.getSaldoactualext())));
		element.setSaldoretenidoext(Util.formatDouble(Util.isNumber(element.getSaldoretenidoext())));
		element.setSaldodisponibleext(Util.formatDouble(Util.isNumber(element.getSaldodisponibleext())));
		element.setUtilidadperdida(Util.formatDouble(Util.isNumber(element.getUtilidadperdida())));
		element.setPeso(Util.formatDoublePorcentaje(Util.isNumber(element.getPeso())));
		element.setPlazo(/*Util.formatDouble(Util.isNumber(*/element.getPlazo());
		element.setTasa(Util.formatDouble(Util.isNumber(element.getTasa())));
		return element;
	}

	public List<HashMap> cambiarEstadoRebalanceo(String codCliente, String idRebalanceo, String estado,
			String observaciones) throws Exception{
		return rebalanceoDAOIface.cambiarEstadoRebalanceo(codCliente, idRebalanceo, estado,observaciones);
	}

	public HashMap validarRebalanceo(String codCliente) throws Exception{
		return rebalanceoDAOIface.validarRebalanceo(codCliente);
	}
		
	public List<Rebalanceo> listarHistoricosRebalanceoNC(Rebalanceo oRebalanceo) {
		List historicos=new ArrayList();
		for (Iterator iter = rebalanceoDAOIface.listarHistoricosRebalanceoNC(oRebalanceo).iterator(); iter.hasNext();) {
			HashMap element = (HashMap) iter.next();
			element.put("fecha",(Util.formatDate(element.get("fecha").toString())));
			historicos.add(element);
		}
		return historicos;
	}
	
	public List<TablaGenerica> listarRebalanceoAnual(String anio, String codUsuAsesor) {
		List<Rebalanceo> listaRebalanciamientoAnual = rebalanceoDAOIface.listarRebalanceoAnual(anio, codUsuAsesor);
		List<TablaGenerica> listaTablaGenerica = new ArrayList<TablaGenerica>();
		List<String> listaAvancePropio = new ArrayList<String>();
		listaAvancePropio.add("Avance Propio");
		List<String> listaAvanceCompartido = new ArrayList<String>();
		listaAvanceCompartido.add("Avance Compartido");
		List<String> listaAcumulado = new ArrayList<String>();
		listaAcumulado.add("Acumulado");
		List<String> listaMeta = new ArrayList<String>();
		listaMeta.add("Meta");
		List<String> listaMetavsAcumulado = new ArrayList<String>();
		listaMetavsAcumulado.add("Meta vs Acumulado");
		if(listaRebalanciamientoAnual!=null && listaRebalanciamientoAnual.size()>0){
			for(Rebalanceo rebalanciamiento : listaRebalanciamientoAnual){
				listaAvancePropio.add(rebalanciamiento.getAvancepropio());
				listaAvanceCompartido.add(rebalanciamiento.getAvancecompartido());
				listaAcumulado.add(rebalanciamiento.getAvanceacumulado());
				listaMeta.add(rebalanciamiento.getMeta());
				listaMetavsAcumulado.add(rebalanciamiento.getMetavsacumulado());
			}
			//Agregando primera fila
			TablaGenerica tg = null;
			//Propio
			tg = new TablaGenerica();
			tg.setCabeceraLateral(listaAvancePropio.get(0));
			tg.setCampo1(listaAvancePropio.get(1));
			tg.setCampo2(listaAvancePropio.get(2));
			tg.setCampo3(listaAvancePropio.get(3));
			tg.setCampo4(listaAvancePropio.get(4));
			tg.setCampo5(listaAvancePropio.get(5));
			tg.setCampo6(listaAvancePropio.get(6));
			tg.setCampo7(listaAvancePropio.get(7));
			tg.setCampo8(listaAvancePropio.get(8));
			tg.setCampo9(listaAvancePropio.get(9));
			tg.setCampo10(listaAvancePropio.get(10));
			tg.setCampo11(listaAvancePropio.get(11));
			tg.setCampo12(listaAvancePropio.get(12));
			tg.setCampo13(listaAvancePropio.get(13));
			tg.setCampo14(listaAvancePropio.get(14));
			tg.setCampo15(listaAvancePropio.get(15));
			tg.setCampo16(listaAvancePropio.get(16));
			tg.setCampo17(listaAvancePropio.get(17));
			tg.setCampo18(listaAvancePropio.get(18));
			tg.setCampo19(listaAvancePropio.get(19));
			tg.setCampo20(listaAvancePropio.get(20));
			tg.setCampo21(listaAvancePropio.get(21));
			tg.setCampo22(listaAvancePropio.get(22));
			tg.setCampo23(listaAvancePropio.get(23));
			tg.setCampo24(listaAvancePropio.get(24));
			tg.setCampo25(listaAvancePropio.get(25));
			tg.setCampo26(listaAvancePropio.get(26));
			tg.setCampo27(listaAvancePropio.get(27));
			tg.setCampo28(listaAvancePropio.get(28));
			tg.setCampo29(listaAvancePropio.get(29));
			tg.setCampo30(listaAvancePropio.get(30));
			tg.setCampo31(listaAvancePropio.get(31));
			tg.setCampo32(listaAvancePropio.get(32));
			tg.setCampo33(listaAvancePropio.get(33));
			tg.setCampo34(listaAvancePropio.get(34));
			tg.setCampo35(listaAvancePropio.get(35));
			tg.setCampo36(listaAvancePropio.get(36));
			tg.setCampo37(listaAvancePropio.get(37));
			tg.setCampo38(listaAvancePropio.get(38));
			tg.setCampo39(listaAvancePropio.get(39));
			tg.setCampo40(listaAvancePropio.get(40));
			tg.setCampo41(listaAvancePropio.get(41));
			tg.setCampo42(listaAvancePropio.get(42));
			tg.setCampo43(listaAvancePropio.get(43));
			tg.setCampo44(listaAvancePropio.get(44));
			tg.setCampo45(listaAvancePropio.get(45));
			tg.setCampo46(listaAvancePropio.get(46));
			tg.setCampo47(listaAvancePropio.get(47));
			tg.setCampo48(listaAvancePropio.get(48));
			listaTablaGenerica.add(tg);
			
			//Compartido
			tg = new TablaGenerica();
			tg.setCabeceraLateral(listaAvanceCompartido.get(0));
			tg.setCampo1(listaAvanceCompartido.get(1));
			tg.setCampo2(listaAvanceCompartido.get(2));
			tg.setCampo3(listaAvanceCompartido.get(3));
			tg.setCampo4(listaAvanceCompartido.get(4));
			tg.setCampo5(listaAvanceCompartido.get(5));
			tg.setCampo6(listaAvanceCompartido.get(6));
			tg.setCampo7(listaAvanceCompartido.get(7));
			tg.setCampo8(listaAvanceCompartido.get(8));
			tg.setCampo9(listaAvanceCompartido.get(9));
			tg.setCampo10(listaAvanceCompartido.get(10));
			tg.setCampo11(listaAvanceCompartido.get(11));
			tg.setCampo12(listaAvanceCompartido.get(12));
			tg.setCampo13(listaAvanceCompartido.get(13));
			tg.setCampo14(listaAvanceCompartido.get(14));
			tg.setCampo15(listaAvanceCompartido.get(15));
			tg.setCampo16(listaAvanceCompartido.get(16));
			tg.setCampo17(listaAvanceCompartido.get(17));
			tg.setCampo18(listaAvanceCompartido.get(18));
			tg.setCampo19(listaAvanceCompartido.get(19));
			tg.setCampo20(listaAvanceCompartido.get(20));
			tg.setCampo21(listaAvanceCompartido.get(21));
			tg.setCampo22(listaAvanceCompartido.get(22));
			tg.setCampo23(listaAvanceCompartido.get(23));
			tg.setCampo24(listaAvanceCompartido.get(24));
			tg.setCampo25(listaAvanceCompartido.get(25));
			tg.setCampo26(listaAvanceCompartido.get(26));
			tg.setCampo27(listaAvanceCompartido.get(27));
			tg.setCampo28(listaAvanceCompartido.get(28));
			tg.setCampo29(listaAvanceCompartido.get(29));
			tg.setCampo30(listaAvanceCompartido.get(30));
			tg.setCampo31(listaAvanceCompartido.get(31));
			tg.setCampo32(listaAvanceCompartido.get(32));
			tg.setCampo33(listaAvanceCompartido.get(33));
			tg.setCampo34(listaAvanceCompartido.get(34));
			tg.setCampo35(listaAvanceCompartido.get(35));
			tg.setCampo36(listaAvanceCompartido.get(36));
			tg.setCampo37(listaAvanceCompartido.get(37));
			tg.setCampo38(listaAvanceCompartido.get(38));
			tg.setCampo39(listaAvanceCompartido.get(39));
			tg.setCampo40(listaAvanceCompartido.get(40));
			tg.setCampo41(listaAvanceCompartido.get(41));
			tg.setCampo42(listaAvanceCompartido.get(42));
			tg.setCampo43(listaAvanceCompartido.get(43));
			tg.setCampo44(listaAvanceCompartido.get(44));
			tg.setCampo45(listaAvanceCompartido.get(45));
			tg.setCampo46(listaAvanceCompartido.get(46));
			tg.setCampo47(listaAvanceCompartido.get(47));
			tg.setCampo48(listaAvanceCompartido.get(48));
			listaTablaGenerica.add(tg);
			
			//Acumulado
			tg = new TablaGenerica();
			tg.setCabeceraLateral(listaAcumulado.get(0));
			tg.setCampo1(listaAcumulado.get(1));
			tg.setCampo2(listaAcumulado.get(2));
			tg.setCampo3(listaAcumulado.get(3));
			tg.setCampo4(listaAcumulado.get(4));
			tg.setCampo5(listaAcumulado.get(5));
			tg.setCampo6(listaAcumulado.get(6));
			tg.setCampo7(listaAcumulado.get(7));
			tg.setCampo8(listaAcumulado.get(8));
			tg.setCampo9(listaAcumulado.get(9));
			tg.setCampo10(listaAcumulado.get(10));
			tg.setCampo11(listaAcumulado.get(11));
			tg.setCampo12(listaAcumulado.get(12));
			tg.setCampo13(listaAcumulado.get(13));
			tg.setCampo14(listaAcumulado.get(14));
			tg.setCampo15(listaAcumulado.get(15));
			tg.setCampo16(listaAcumulado.get(16));
			tg.setCampo17(listaAcumulado.get(17));
			tg.setCampo18(listaAcumulado.get(18));
			tg.setCampo19(listaAcumulado.get(19));
			tg.setCampo20(listaAcumulado.get(20));
			tg.setCampo21(listaAcumulado.get(21));
			tg.setCampo22(listaAcumulado.get(22));
			tg.setCampo23(listaAcumulado.get(23));
			tg.setCampo24(listaAcumulado.get(24));
			tg.setCampo25(listaAcumulado.get(25));
			tg.setCampo26(listaAcumulado.get(26));
			tg.setCampo27(listaAcumulado.get(27));
			tg.setCampo28(listaAcumulado.get(28));
			tg.setCampo29(listaAcumulado.get(29));
			tg.setCampo30(listaAcumulado.get(30));
			tg.setCampo31(listaAcumulado.get(31));
			tg.setCampo32(listaAcumulado.get(32));
			tg.setCampo33(listaAcumulado.get(33));
			tg.setCampo34(listaAcumulado.get(34));
			tg.setCampo35(listaAcumulado.get(35));
			tg.setCampo36(listaAcumulado.get(36));
			tg.setCampo37(listaAcumulado.get(37));
			tg.setCampo38(listaAcumulado.get(38));
			tg.setCampo39(listaAcumulado.get(39));
			tg.setCampo40(listaAcumulado.get(40));
			tg.setCampo41(listaAcumulado.get(41));
			tg.setCampo42(listaAcumulado.get(42));
			tg.setCampo43(listaAcumulado.get(43));
			tg.setCampo44(listaAcumulado.get(44));
			tg.setCampo45(listaAcumulado.get(45));
			tg.setCampo46(listaAcumulado.get(46));
			tg.setCampo47(listaAcumulado.get(47));
			tg.setCampo48(listaAcumulado.get(48));
			listaTablaGenerica.add(tg);
			
//			Meta
			tg = new TablaGenerica();
			tg.setCabeceraLateral(listaMeta.get(0));
			tg.setCampo1(listaMeta.get(1));
			tg.setCampo2(listaMeta.get(2));
			tg.setCampo3(listaMeta.get(3));
			tg.setCampo4(listaMeta.get(4));
			tg.setCampo5(listaMeta.get(5));
			tg.setCampo6(listaMeta.get(6));
			tg.setCampo7(listaMeta.get(7));
			tg.setCampo8(listaMeta.get(8));
			tg.setCampo9(listaMeta.get(9));
			tg.setCampo10(listaMeta.get(10));
			tg.setCampo11(listaMeta.get(11));
			tg.setCampo12(listaMeta.get(12));
			tg.setCampo13(listaMeta.get(13));
			tg.setCampo14(listaMeta.get(14));
			tg.setCampo15(listaMeta.get(15));
			tg.setCampo16(listaMeta.get(16));
			tg.setCampo17(listaMeta.get(17));
			tg.setCampo18(listaMeta.get(18));
			tg.setCampo19(listaMeta.get(19));
			tg.setCampo20(listaMeta.get(20));
			tg.setCampo21(listaMeta.get(21));
			tg.setCampo22(listaMeta.get(22));
			tg.setCampo23(listaMeta.get(23));
			tg.setCampo24(listaMeta.get(24));
			tg.setCampo25(listaMeta.get(25));
			tg.setCampo26(listaMeta.get(26));
			tg.setCampo27(listaMeta.get(27));
			tg.setCampo28(listaMeta.get(28));
			tg.setCampo29(listaMeta.get(29));
			tg.setCampo30(listaMeta.get(30));
			tg.setCampo31(listaMeta.get(31));
			tg.setCampo32(listaMeta.get(32));
			tg.setCampo33(listaMeta.get(33));
			tg.setCampo34(listaMeta.get(34));
			tg.setCampo35(listaMeta.get(35));
			tg.setCampo36(listaMeta.get(36));
			tg.setCampo37(listaMeta.get(37));
			tg.setCampo38(listaMeta.get(38));
			tg.setCampo39(listaMeta.get(39));
			tg.setCampo40(listaMeta.get(40));
			tg.setCampo41(listaMeta.get(41));
			tg.setCampo42(listaMeta.get(42));
			tg.setCampo43(listaMeta.get(43));
			tg.setCampo44(listaMeta.get(44));
			tg.setCampo45(listaMeta.get(45));
			tg.setCampo46(listaMeta.get(46));
			tg.setCampo47(listaMeta.get(47));
			tg.setCampo48(listaMeta.get(48));
			listaTablaGenerica.add(tg);
			
//			Meta vs Acumulado
			tg = new TablaGenerica();
			String simPorc = "%";
			tg.setCabeceraLateral(listaMetavsAcumulado.get(0));
			tg.setCampo1(listaMetavsAcumulado.get(1)+simPorc);
			tg.setCampo2(listaMetavsAcumulado.get(2)+simPorc);
			tg.setCampo3(listaMetavsAcumulado.get(3)+simPorc);
			tg.setCampo4(listaMetavsAcumulado.get(4)+simPorc);
			tg.setCampo5(listaMetavsAcumulado.get(5)+simPorc);
			tg.setCampo6(listaMetavsAcumulado.get(6)+simPorc);
			tg.setCampo7(listaMetavsAcumulado.get(7)+simPorc);
			tg.setCampo8(listaMetavsAcumulado.get(8)+simPorc);
			tg.setCampo9(listaMetavsAcumulado.get(9)+simPorc);
			tg.setCampo10(listaMetavsAcumulado.get(10)+simPorc);
			tg.setCampo11(listaMetavsAcumulado.get(11)+simPorc);
			tg.setCampo12(listaMetavsAcumulado.get(12)+simPorc);
			tg.setCampo13(listaMetavsAcumulado.get(13)+simPorc);
			tg.setCampo14(listaMetavsAcumulado.get(14)+simPorc);
			tg.setCampo15(listaMetavsAcumulado.get(15)+simPorc);
			tg.setCampo16(listaMetavsAcumulado.get(16)+simPorc);
			tg.setCampo17(listaMetavsAcumulado.get(17)+simPorc);
			tg.setCampo18(listaMetavsAcumulado.get(18)+simPorc);
			tg.setCampo19(listaMetavsAcumulado.get(19)+simPorc);
			tg.setCampo20(listaMetavsAcumulado.get(20)+simPorc);
			tg.setCampo21(listaMetavsAcumulado.get(21)+simPorc);
			tg.setCampo22(listaMetavsAcumulado.get(22)+simPorc);
			tg.setCampo23(listaMetavsAcumulado.get(23)+simPorc);
			tg.setCampo24(listaMetavsAcumulado.get(24)+simPorc);
			tg.setCampo25(listaMetavsAcumulado.get(25)+simPorc);
			tg.setCampo26(listaMetavsAcumulado.get(26)+simPorc);
			tg.setCampo27(listaMetavsAcumulado.get(27)+simPorc);
			tg.setCampo28(listaMetavsAcumulado.get(28)+simPorc);
			tg.setCampo29(listaMetavsAcumulado.get(29)+simPorc);
			tg.setCampo30(listaMetavsAcumulado.get(30)+simPorc);
			tg.setCampo31(listaMetavsAcumulado.get(31)+simPorc);
			tg.setCampo32(listaMetavsAcumulado.get(32)+simPorc);
			tg.setCampo33(listaMetavsAcumulado.get(33)+simPorc);
			tg.setCampo34(listaMetavsAcumulado.get(34)+simPorc);
			tg.setCampo35(listaMetavsAcumulado.get(35)+simPorc);
			tg.setCampo36(listaMetavsAcumulado.get(36)+simPorc);
			tg.setCampo37(listaMetavsAcumulado.get(37)+simPorc);
			tg.setCampo38(listaMetavsAcumulado.get(38)+simPorc);
			tg.setCampo39(listaMetavsAcumulado.get(39)+simPorc);
			tg.setCampo40(listaMetavsAcumulado.get(40)+simPorc);
			tg.setCampo41(listaMetavsAcumulado.get(41)+simPorc);
			tg.setCampo42(listaMetavsAcumulado.get(42)+simPorc);
			tg.setCampo43(listaMetavsAcumulado.get(43)+simPorc);
			tg.setCampo44(listaMetavsAcumulado.get(44)+simPorc);
			tg.setCampo45(listaMetavsAcumulado.get(45)+simPorc);
			tg.setCampo46(listaMetavsAcumulado.get(46)+simPorc);
			tg.setCampo47(listaMetavsAcumulado.get(47)+simPorc);
			tg.setCampo48(listaMetavsAcumulado.get(48)+simPorc);
			listaTablaGenerica.add(tg);
		}
		return listaTablaGenerica;
	}
	
	public List<Rebalanceo> listarResultadoRebalanceo(String codUsuAsesor) {
		List <Rebalanceo> listaResultadoRebalanceo = rebalanceoDAOIface.listarResultadoRebalanceo(codUsuAsesor);
		if(listaResultadoRebalanceo!=null && listaResultadoRebalanceo.size()>0){
			int cantidad = 0;
			double porcentaje = 0;
			for(Rebalanceo rebalanceo : listaResultadoRebalanceo){
				cantidad = cantidad + Integer.parseInt(rebalanceo.getCantidad());
				porcentaje = porcentaje + Double.parseDouble(rebalanceo.getPeso());
				rebalanceo.setPeso(rebalanceo.getPeso());//+"%"
			}
			Rebalanceo rebalanceoTotal = new Rebalanceo();
			rebalanceoTotal.setDescripcion("Totales");
			rebalanceoTotal.setCantidad(cantidad+"");
			rebalanceoTotal.setPeso(""+porcentaje);//+"%"
			listaResultadoRebalanceo.add(rebalanceoTotal);
		}
		return listaResultadoRebalanceo;
	}
	
	/*
	 * PESTANA DE GESTION DE REBALANCEO DE RESULTADOS POR PERIODO
	 * */
	public List<Rebalanceo> listarResultadoPorPeriodo(String codUsuAsesor) {
		List <Rebalanceo> listaResultadoPorPeriodo = rebalanceoDAOIface.listarResultadoPorPeriodo(codUsuAsesor);
		if(listaResultadoPorPeriodo!=null && listaResultadoPorPeriodo.size()>0){
			int cantidad = 0;
			double porcentaje = 0;
			for(Rebalanceo rebalanceo : listaResultadoPorPeriodo){
				cantidad = cantidad + Integer.parseInt(rebalanceo.getCantidad());
				porcentaje = porcentaje + Double.parseDouble(rebalanceo.getPeso());
				rebalanceo.setPeso(rebalanceo.getPeso());
			}
			Rebalanceo rebalanceoTotal = new Rebalanceo();
			rebalanceoTotal.setDescripcion("Totales");
			rebalanceoTotal.setCantidad(cantidad+"");
			rebalanceoTotal.setPeso(""+porcentaje);
			listaResultadoPorPeriodo.add(rebalanceoTotal);
		}
		return listaResultadoPorPeriodo;
	}
	
	public List listarPosicionContratoRebalanceadoIndicador(String codCliente,PosicionContrato objContratoTotal,List listAux) {
		
		List listResult=new ArrayList();
		List lista=rebalanceoDAOIface.listarPosicionContrato(codCliente);
		List subList=new ArrayList();
		ListaGenerica mainList=new ListaGenerica();
		if(lista.size()>0){
		PosicionContrato posicionContrato=(PosicionContrato)lista.get(0);
		String descripcion=Util.isString(posicionContrato.getDescripcioncateporcontrato());
		String codCatContrato=Util.isString(posicionContrato.getCodcategoriaporcontrato());
		Double saldoactualext=new Double(0);
		Double saldoretenidoext=new Double(0);
		Double saldodisponibleext=new Double(0);
		Double utilidadperdida=new Double(0);
		Double peso=new Double(0);
		Double saldoactualext_tt=new Double(0);
		Double saldoretenidoext_tt=new Double(0);
		Double saldodisponibleext_tt=new Double(0);
		Double utilidadperdida_tt=new Double(0);
		Double peso_tt=new Double(0);
		String descripcion_aux="";
		String codCatContrato_aux="";
		PosicionContrato element = null;
		PosicionContrato elementAux = null;

		for (Iterator iter = lista.iterator(); iter.hasNext();) {
			element = (PosicionContrato) iter.next();
			for (Iterator iterAux = listAux.iterator(); iterAux.hasNext();){
				elementAux = (PosicionContrato) iterAux.next();				
				if(elementAux.getStrparticiparebalanceo().equals("S") && 
						(elementAux.getCodcontrato().replace("-", "").trim()).equals(element.getCodcontrato().trim()) && 
						(elementAux.getCodcliente().trim()).equals(element.getCodcliente().trim()) ){
					element.setIndparticiparebalanceo(element.getStrparticiparebalanceo().equals("S")?true:false);
					descripcion_aux=descripcion;
					codCatContrato_aux=codCatContrato;
					descripcion=Util.isString(element.getDescripcioncateporcontrato());
					codCatContrato=Util.isString(element.getCodcategoriaporcontrato());
					if(!descripcion_aux.equals(descripcion)){//quiebre
						mainList=new ListaGenerica();
						mainList.setObj(new PosicionContrato());
						mainList.setSubLista(subList);
						llenaTotalesContrato((PosicionContrato)mainList.getObj(),codCatContrato_aux,"Total "+descripcion_aux,saldoactualext,
								saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
						listResult.add(mainList);
						subList=new ArrayList();
						saldoactualext=new Double(0);
						saldoretenidoext=new Double(0);
						saldodisponibleext=new Double(0);
						utilidadperdida=new Double(0);
						peso=new Double(0);
					}
					saldoactualext+=Util.isNumber(element.getSaldoactualext());
					saldoretenidoext+=Util.isNumber(element.getSaldoretenidoext());
					saldodisponibleext+=Util.isNumber(element.getSaldodisponibleext());
					utilidadperdida+=Util.isNumber(element.getUtilidadperdida());
					peso+=Util.isNumber(element.getPeso());
					saldoactualext_tt+=Util.isNumber(element.getSaldoactualext());
					saldoretenidoext_tt+=Util.isNumber(element.getSaldoretenidoext());
					saldodisponibleext_tt+=Util.isNumber(element.getSaldodisponibleext());
					utilidadperdida_tt+=Util.isNumber(element.getUtilidadperdida());
					peso_tt+=Util.isNumber(element.getPeso());
					subList.add(formateaElementos(element));
				}
			}
		}
		mainList=new ListaGenerica();
		
		mainList.setObj(new PosicionContrato());
		llenaTotalesContrato((PosicionContrato)mainList.getObj(),codCatContrato,"Total "+descripcion,saldoactualext,
				saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
		mainList.setSubLista(subList);
		listResult.add(mainList);
		//Adicinando Totales Finales
		llenaTotalesContrato(objContratoTotal,"","Totales",saldoactualext_tt,
				saldoretenidoext_tt,saldodisponibleext_tt,utilidadperdida_tt,peso_tt);
		}
		return listResult;
	}

	public List listarPosicionDetalleRebalanceadoIndicador(String codCliente,PosicionDetalle objContratoTotal,List listAux) {
		List listResult=new ArrayList();
		List lista=listAux;
		List subList=new ArrayList();
		ListaGenerica mainList=new ListaGenerica();
		if(lista.size()>0){
			PosicionDetalle posicionDetalle=(PosicionDetalle)lista.get(0);
			String descripcion=Util.isString(posicionDetalle.getDescategoriaporproducto());
			Double saldoactualext=new Double(0);
			Double saldoretenidoext=new Double(0);
			Double saldodisponibleext=new Double(0);
			Double utilidadperdida=new Double(0);
			Double peso=new Double(0);
			Double saldoactualext_tt=new Double(0);
			Double saldoretenidoext_tt=new Double(0);
			Double saldodisponibleext_tt=new Double(0);
			Double utilidadperdida_tt=new Double(0);
			Double peso_tt=new Double(0);
			String descripcion_aux="";
			PosicionDetalle element = null;
			for (Iterator iter = lista.iterator(); iter.hasNext();) {
				element = (PosicionDetalle) iter.next();
				descripcion_aux=descripcion;
				descripcion=Util.isString(element.getDescategoriaporproducto());
				if(!descripcion_aux.equals(descripcion)){//quiebre
					mainList=new ListaGenerica();
					mainList.setSubLista(subList);
					mainList.setObj(new PosicionDetalle());
					llenaTotalesDetalle((PosicionDetalle)mainList.getObj(),"Total "+descripcion_aux,saldoactualext,
							saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
					listResult.add(mainList);
					subList=new ArrayList();
					saldoactualext=new Double(0);
					saldoretenidoext=new Double(0);
					saldodisponibleext=new Double(0);
					utilidadperdida=new Double(0);
					peso=new Double(0);
				}
				if(element.isIndparticiparebalanceo()){
					saldoactualext+=Util.isNumber(element.getSaldoactualext().replace(",", ""));
					saldoretenidoext+=Util.isNumber(element.getSaldoretenidoext().replace(",", ""));
					saldodisponibleext+=Util.isNumber(element.getSaldodisponibleext().replace(",", ""));
					utilidadperdida+=Util.isNumber(element.getUtilidadperdida().replace(",", ""));
					peso+=Util.isNumber(element.getPeso().replace(",", ""));
					saldoactualext_tt+=Util.isNumber(element.getSaldoactualext().replace(",", ""));
					saldoretenidoext_tt+=Util.isNumber(element.getSaldoretenidoext().replace(",", ""));
					saldodisponibleext_tt+=Util.isNumber(element.getSaldodisponibleext().replace(",", ""));
					utilidadperdida_tt+=Util.isNumber(element.getUtilidadperdida().replace(",", ""));
					peso_tt+=Util.isNumber(element.getPeso().replace(",", ""));
					subList.add(element);
				}			
			}
			mainList=new ListaGenerica();
			mainList.setObj(new PosicionDetalle());
			llenaTotalesDetalle((PosicionDetalle)mainList.getObj(),"Total "+descripcion,saldoactualext,
					saldoretenidoext,saldodisponibleext,utilidadperdida,peso);
			mainList.setSubLista(subList);
			listResult.add(mainList);
			//		Adicinando Totales Finales
			llenaTotalesDetalle(objContratoTotal,"Totales",saldoactualext_tt,
					saldoretenidoext_tt,saldodisponibleext_tt,utilidadperdida_tt,peso_tt);
		}
		return listResult;
	}
	
	public Map<String,List<Map<String,Object>>> consultarDetalleRebalanceo(String idRebalanceo){
		List<Map<String,Object>> listaDetalleRebalanceo=rebalanceoDAOIface.listarDetalleRebalanceo(idRebalanceo);
		List<Map<String, Object>> listaCalculadora=listarDistribucion(filtrar(listaDetalleRebalanceo,Constantes.CONSTANTE_CALCULADORA_TIPO_BBVA));
		List<Map<String, Object>> listaRecursos=listarDistribucion(filtrar(listaDetalleRebalanceo,Constantes.CONSTANTE_CALCULADORA_TIPO_RECURSOS));
		Map<String,List<Map<String,Object>>> map=new HashMap<String, List<Map<String,Object>>>();
		map.put("bbva", listaCalculadora);
		map.put("recursos", listaRecursos);		
		map.put("listaDistribActivos",rebalanceoDAOIface.listarDetalleRebalanceoDistribucion(idRebalanceo));		
		return map;
	}
	
	private List<Map<String,Object>> filtrar(List<Map<String,Object>> listaDistribucion,String tipo){
		List<Map<String,Object>> lista=new ArrayList<Map<String,Object>>();
		for(Map<String,Object> fila:listaDistribucion){
			if(fila.get("tipo").toString().equals(tipo)){
				lista.add(fila);
			}
		}
		return lista;
	}
	
	private List<Map<String,Object>> listarDistribucion(List<Map<String,Object>> listaDistribucion) {				
		List<Map<String, Object>> listaPadre=new ArrayList<Map<String,Object>>();
		if(listaDistribucion.size()>0){
			List<RebalanceoTO> sublista=new ArrayList<RebalanceoTO>();
			RebalanceoTO reba=new RebalanceoTO();
			String idCatProducto=listaDistribucion.get(0).get("idcategoriaporproducto").toString();		
			for(Map<String, Object> x:listaDistribucion){
				if(!x.get("idcategoriaporproducto").toString().equals(idCatProducto)){
					idCatProducto=x.get("idcategoriaporproducto").toString();
					//agregar pie
					Map<String,Object> item=new HashMap<String, Object>();
					item.put("detalle", sublista);
					item.put("pie", new RebalanceoTO());					
					listaPadre.add(item);
					sublista=new ArrayList<RebalanceoTO>();
				}
				reba=new RebalanceoTO();				
				reba.setDescripcion(Util.nvl(x.get("descripcion")).toString());
				reba.setMoneda(Util.nvl(x.get("moneda")).toString());				
				reba.setCodCatProd(Util.nvl(x.get("idcategoriaporproducto")).toString());
				reba.setCodCatActivo((Util.nvl(x.get("idcategoriaactivo"))).toString());
				reba.setCodProd(Util.nvl(x.get("codproducto")).toString());
				reba.setCodSubProd(Util.nvl(x.get("codsubproducto")).toString());
				reba.setPlazo(Util.nvl(x.get("plazo")).toString());
				reba.setSaldoActual(Util.nvl(x.get("saldoactual")).toString());
				reba.setSaldoRentenido(Util.big(Util.nvl(x.get("saldoretenido")).toString()));
				reba.setRentabilidad(Util.nvl(x.get("rentabilidad")).toString());
				reba.setSaldoInputPEN(Util.nvl(x.get("calculadorapen")).toString());
				reba.setSaldoInputUSD(Util.nvl(x.get("calculadorausd")).toString());
				reba.setSaldoInputEUR(Util.nvl(x.get("calculadoraeur")).toString());
				reba.setRentabilidadEstimada(Util.nvl(x.get("rentabilidadestimada")).toString());
				reba.setSaldoResultante(Util.big(String.valueOf(x.get("saldoresultante"))));
				reba.setPeso(Util.big(String.valueOf(x.get("peso"))));
				sublista.add(reba);								
			}
			Map<String,Object> item=new HashMap<String, Object>();
			item.put("detalle", sublista);
			item.put("pie", new RebalanceoTO());
			listaPadre.add(item);
		}	
		return listaPadre;
	}
	
	public Map<String,ArrayList<DetalleRebalanceoTO>> obtenerDetalle(String idRebalanceo) throws Exception{
		return rebalanceoDAOIface.obtenerDetalle(idRebalanceo);
	}
	
	public String guardarDetalleRebalanceo(List<DetalleRebalanceoTO> listaDetalleRebalanceoBonos,
											List<DetalleRebalanceoTO> listaDetalleRebalanceoOperaciones,
											List<DetalleRebalanceoTO> listaDetalleRebalanceoAcciones,
											List<DetalleRebalanceoTO> listaDetalleRebalanceoDepositosEstructurados,
											List<DetalleRebalanceoTO> listaDetalleRebalanceoOpcion, String idRebalanceo,
											boolean initListDataBono, boolean initListDataOper, boolean initListDataAcciones,
											boolean initListDataDepEstruct, boolean initListDataOpciones){
		String msgError = "";
		if(!guardarBonos(listaDetalleRebalanceoBonos, idRebalanceo, initListDataBono)){
			msgError = msgError + " BONOS,";
		}
		if(!guardarOperaciones(listaDetalleRebalanceoOperaciones, idRebalanceo, initListDataOper)){
			msgError = msgError + " OPERACIONES DE REPORTE,";
		}
		if(!guardarAcciones(listaDetalleRebalanceoAcciones, idRebalanceo, initListDataAcciones)){
			msgError = msgError + " ACCIONES,";
		}
		if(!guardarDepEstructurados(listaDetalleRebalanceoDepositosEstructurados, idRebalanceo, initListDataDepEstruct)){
			msgError = msgError + " ESTRUCTURADO,";
		}
		if(!guardarOpciones(listaDetalleRebalanceoOpcion, idRebalanceo, initListDataOpciones)){
			msgError = msgError + "OPCIONES,";
		}
		
		if(msgError.length() > 0){
			msgError = "No se pudo guardar en:"+msgError;
			msgError = msgError.substring(0, msgError.length()-1);
		}
		
		return msgError;
	}
	
	private boolean guardarBonos(List<DetalleRebalanceoTO> listaFinalDetalleRebalanceoBonos, String idRebalanceo, boolean initListData){
		String flagPreInsert = "";
		StringBuilder nemotecnico= new StringBuilder();
		StringBuilder emisor= new StringBuilder();
		StringBuilder codsector= new StringBuilder();
		StringBuilder codTipoInstrumento= new StringBuilder();
		StringBuilder codMoneda= new StringBuilder();
		StringBuilder montoInvertir= new StringBuilder();
		StringBuilder rendimiento= new StringBuilder();
		StringBuilder fechaInicio= new StringBuilder();
		StringBuilder fechaVencimiento= new StringBuilder();
		StringBuilder duracion= new StringBuilder();
		StringBuilder codAmortizacion= new StringBuilder();
		StringBuilder codFrecuenciaPago= new StringBuilder();
		StringBuilder riesgoCrediticio= new StringBuilder();
		
		if(listaFinalDetalleRebalanceoBonos.size()>0){
			flagPreInsert = "1";
			for(DetalleRebalanceoTO fila:listaFinalDetalleRebalanceoBonos){
				nemotecnico.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getNemotecnico());
				emisor.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getEmisor());
				codsector.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodSector());
				codTipoInstrumento.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodTipoInstrumento());
				codMoneda.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodMoneda());
				montoInvertir.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getMontoInvertir());
				rendimiento.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getRendimiento());
				fechaInicio.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(Util.formatDate(fila.getFechaInicio(),Constantes.formatoFechaApp));
				fechaVencimiento.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(Util.formatDate(fila.getFechaVencimiento(),Constantes.formatoFechaApp));
				duracion.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getDuracion());
				codAmortizacion.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodAmortizacion());
				codFrecuenciaPago.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodFrecuenciaPago());
				riesgoCrediticio.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getRiesgoCrediticio());
			}		
		}
		
		if(initListData || listaFinalDetalleRebalanceoBonos.size() > 0){
			try{
				rebalanceoDAOIface.guardarInformacionAdicionalBonos(Util.getSubStringBuilderStart(nemotecnico),
						Util.getSubStringBuilderStart(emisor),
						Util.getSubStringBuilderStart(codsector),
						Util.getSubStringBuilderStart(codTipoInstrumento),
						Util.getSubStringBuilderStart(codMoneda),
						Util.getSubStringBuilderStart(montoInvertir),
						Util.getSubStringBuilderStart(rendimiento),
						Util.getSubStringBuilderStart(fechaInicio),
						Util.getSubStringBuilderStart(fechaVencimiento),
						Util.getSubStringBuilderStart(duracion),
						Util.getSubStringBuilderStart(codAmortizacion),
						Util.getSubStringBuilderStart(codFrecuenciaPago),
						Util.getSubStringBuilderStart(riesgoCrediticio),
						idRebalanceo, flagPreInsert);
			}catch(Exception e){
				e.printStackTrace();
				return false;
			}
		}
		return true;
	}
	
	private boolean guardarOperaciones(List<DetalleRebalanceoTO> listaFinalDetalleRebalanceoOperaciones, String idRebalanceo, boolean initListData){
		String flagPreInsert = "";
		StringBuilder codMoneda= new StringBuilder();
		StringBuilder precioContado= new StringBuilder();
		StringBuilder precioPlazo= new StringBuilder();
		StringBuilder rendimiento= new StringBuilder();
		StringBuilder fechaInicio= new StringBuilder();
		StringBuilder fechaVencimiento= new StringBuilder();
		StringBuilder montoInvertir= new StringBuilder();
		
		if(listaFinalDetalleRebalanceoOperaciones.size()>0){
			flagPreInsert = "1";
			for(DetalleRebalanceoTO fila:listaFinalDetalleRebalanceoOperaciones){
				codMoneda.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodMoneda());
				precioContado.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getPrecioContado());
				precioPlazo.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getPrecioPlazo());
				montoInvertir.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getMontoInvertir());
				rendimiento.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getRendimiento());
				fechaInicio.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(Util.formatDate(fila.getFechaInicio(),Constantes.formatoFechaApp));
				fechaVencimiento.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(Util.formatDate(fila.getFechaVencimiento(),Constantes.formatoFechaApp));
			}		
		}
		
		if(initListData || listaFinalDetalleRebalanceoOperaciones.size() > 0){
			try{
				rebalanceoDAOIface.guardarInformacionAdicionalOperaciones(Util.getSubStringBuilderStart(codMoneda),
						Util.getSubStringBuilderStart(precioContado),
						Util.getSubStringBuilderStart(precioPlazo),
						Util.getSubStringBuilderStart(rendimiento),
						Util.getSubStringBuilderStart(fechaInicio),
						Util.getSubStringBuilderStart(fechaVencimiento),
						Util.getSubStringBuilderStart(montoInvertir),
						idRebalanceo, flagPreInsert);
			}catch(Exception e){
				e.printStackTrace();
				return false;
			}
		}
		return true;
	}
	
	private boolean guardarAcciones(List<DetalleRebalanceoTO> listaFinalDetalleRebalanceoAcciones, String idRebalanceo, boolean initListData){
		String flagPreInsert = "";
		StringBuilder nemotecnico= new StringBuilder();
		StringBuilder empresa= new StringBuilder();
		StringBuilder codsector= new StringBuilder();			
		StringBuilder codMoneda= new StringBuilder();
		StringBuilder precioObjetivo= new StringBuilder();
		StringBuilder cotizacionAnual= new StringBuilder();
		StringBuilder maximo= new StringBuilder();
		StringBuilder minimo= new StringBuilder();
		StringBuilder participacionPortafolio= new StringBuilder();
		StringBuilder montoInvertir= new StringBuilder();	
		
		if(listaFinalDetalleRebalanceoAcciones.size()>0){
			flagPreInsert = "1";
			for(DetalleRebalanceoTO fila:listaFinalDetalleRebalanceoAcciones){
				nemotecnico.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getNemotecnico());
				empresa.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getEmpresa());
				codsector.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodSector());				
				codMoneda.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodMoneda());				
				precioObjetivo.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getPrecioObjetivo());
				cotizacionAnual.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCotizacionActual());
				maximo.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getMaximo());
				minimo.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getMinimo());
				participacionPortafolio.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getParticipacionPortafolio());				
				montoInvertir.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getMontoInvertir());
			}		
		}
		
		if(initListData || listaFinalDetalleRebalanceoAcciones.size() > 0){
			try{
				rebalanceoDAOIface.guardarInformacionAdicionalAcciones(Util.getSubStringBuilderStart(nemotecnico),
						Util.getSubStringBuilderStart(empresa),
						Util.getSubStringBuilderStart(codsector),
						Util.getSubStringBuilderStart(codMoneda),																
						Util.getSubStringBuilderStart(precioObjetivo),
						Util.getSubStringBuilderStart(cotizacionAnual),
						Util.getSubStringBuilderStart(maximo),
						Util.getSubStringBuilderStart(minimo),
						Util.getSubStringBuilderStart(participacionPortafolio),
						Util.getSubStringBuilderStart(montoInvertir),																
						idRebalanceo, flagPreInsert);
			}catch(Exception e){
				e.printStackTrace();
				return false;
			}
		}
		return true;
	}
	
	private boolean guardarDepEstructurados(List<DetalleRebalanceoTO> listaFinalDetalleRebalanceoDepositosEstructurados, String idRebalanceo,
			boolean initListData){
		String flagPreInsert = "";
		StringBuilder instrumento= new StringBuilder();
		StringBuilder subyacente= new StringBuilder();						
		StringBuilder codMoneda= new StringBuilder();
		StringBuilder cap= new StringBuilder();
		StringBuilder timg= new StringBuilder();			
		StringBuilder montoInvertir= new StringBuilder();	
		
		if(listaFinalDetalleRebalanceoDepositosEstructurados.size()>0){
			flagPreInsert = "1";
			for(DetalleRebalanceoTO fila:listaFinalDetalleRebalanceoDepositosEstructurados){
				instrumento.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getInstrumento());
				subyacente.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getSubyacente());								
				codMoneda.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodMoneda());				
				cap.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCap());
				timg.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getTimg());								
				montoInvertir.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getMontoInvertir());
			}		
		}
		
		if(initListData || listaFinalDetalleRebalanceoDepositosEstructurados.size() > 0){
			try{
				rebalanceoDAOIface.guardarInformacionAdicionalDepEstructurados(Util.getSubStringBuilderStart(instrumento),
						Util.getSubStringBuilderStart(subyacente),																	
						Util.getSubStringBuilderStart(codMoneda),																
						Util.getSubStringBuilderStart(cap),
						Util.getSubStringBuilderStart(timg),																	
						Util.getSubStringBuilderStart(montoInvertir),																
						idRebalanceo, flagPreInsert);
			}catch(Exception e){
				e.printStackTrace();
				return false;
			}
		}
		return true;
	}
	
	private boolean guardarOpciones(List<DetalleRebalanceoTO> listaFinalDetalleRebalanceoOpcion, String idRebalanceo, boolean initListData){
		String flagPreInsert = "";
		StringBuilder tipo= new StringBuilder();
		StringBuilder subyacente= new StringBuilder();						
		StringBuilder clase= new StringBuilder();
		StringBuilder codMoneda= new StringBuilder();
		StringBuilder primaInversion= new StringBuilder();			
		StringBuilder montoInversion= new StringBuilder();					
		StringBuilder porcentajePrima= new StringBuilder();
		StringBuilder plazo= new StringBuilder();
		
		if(listaFinalDetalleRebalanceoOpcion.size()>0){
			flagPreInsert = "1";
			for(DetalleRebalanceoTO fila:listaFinalDetalleRebalanceoOpcion){
				tipo.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getTipo());
				subyacente.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getSubyacente());								
				clase.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getClase());
				codMoneda.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getCodMoneda());				
				primaInversion.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getPrimaInversion());
				montoInversion.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getMontoInversion());								
				porcentajePrima.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getPorcentajePrima());
				plazo.append(Constantes.CONSTANTE_SEPARADOR_ARRAY_STORE).append(fila.getPlazo());
			}
		}
		
		if(initListData || listaFinalDetalleRebalanceoOpcion.size() > 0){
			try{
				rebalanceoDAOIface.guardarInformacionAdicionalOpciones(Util.getSubStringBuilderStart(tipo),
						Util.getSubStringBuilderStart(subyacente),	
						Util.getSubStringBuilderStart(clase),
						Util.getSubStringBuilderStart(codMoneda),																
						Util.getSubStringBuilderStart(primaInversion),
						Util.getSubStringBuilderStart(montoInversion),																	
						Util.getSubStringBuilderStart(porcentajePrima),
						Util.getSubStringBuilderStart(plazo),																
						idRebalanceo, flagPreInsert);
			}catch(Exception e){
				e.printStackTrace();
				return false;
			}
		}
		return true;
	}

	public void listarPosicionContratoSeleccionados(PosicionContrato objContratoTotal, List listContratoProductos, List listContratosSeleccionados) {
	}

	public List<DetallePorContratos> obtenerListaReporteContratosSeleccionados(List listaContratoProductosS, PosicionContrato rebalanceoContratoTotalRebalanceado) {
		return null;
	}

	public void listarPosicionContratoDetalleSeleccionados(PosicionDetalle objContratoTotal, List listContratoProductos, List listContratosSeleccionados) {
	}

	public List<DetallePorContratos> obtenerListaReporteContratosDetalleSeleccionados(List listaContratoProductosS, PosicionDetalle rebalanceoContratoTotalRebalanceado) {
		return null;
	}

	public String listarIdsCodContrato(String idrebalanceocontrato) {
		return rebalanceoDAOIface.listarIdsCodContrato(idrebalanceocontrato);
	}
	
	public String clonarRebalanceo(String idrebalanceo){
		return null;
	}

	@Override
	public List<Map> listarAutocompleteNemotecnicoBono(String inNemoTecnico)
			throws Exception {
		return rebalanceoDAOIface.listarAutocompleteNemotecnicoBono(inNemoTecnico);
	}

	@Override
	public List<Map> listarAutocompleteNemotecnicoAcciones(
			String inNemoTecnico) throws Exception {
		return rebalanceoDAOIface.listarAutocompleteNemotecnicoAcciones(inNemoTecnico);
	}
	
}
